home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 2: CDPD 1 / Almathera Ten on Ten - Disc 2: CDPD 1.iso / pd / 301-325 / 325 / rexxhostlib / rexxhostlib.c < prev    next >
C/C++ Source or Header  |  1995-03-14  |  8KB  |  389 lines
  1. /* $Revision Header * Header built automatically - do not edit! *************
  2.  *
  3.  *    (C) Copyright 1990 by ???
  4.  *
  5.  *    Name .....: RexxHostLib.c
  6.  *    Created ..: Sunday 07-Jan-90 18:55
  7.  *    Revision .: 6
  8.  *
  9.  *    Date            Author          Comment
  10.  *    =========       ========        ====================
  11.  *    07-Jan-90       Olsen           Added string conversion functions
  12.  *    07-Jan-90       Olsen           Added GetToken
  13.  *    07-Jan-90       Olsen           - Empty log message -
  14.  *    07-Jan-90       Olsen           Removed bug in SendRexxCommand
  15.  *    07-Jan-90       Olsen           - Empty log message -
  16.  *    07-Jan-90       Olsen           - Empty log message -
  17.  *    07-Jan-90       Olsen           Created this file!
  18.  *
  19.  ****************************************************************************
  20.  *
  21.  *    This Amiga shared library is based on example source code
  22.  *    written by Gary Samad & Bill Hawes. It also employs basic
  23.  *    library concepts introduced by Jimm Mackraz (ELib) and
  24.  *    Edwin Hoogerbeets (MkLib). This library was generated using
  25.  *    a customized version of the MkLib utility.
  26.  *
  27.  * $Revision Header ********************************************************/
  28.  #define REVISION 6
  29.  
  30. #include <rexx/storage.h>
  31. #include <rexx/rxslib.h>
  32.  
  33. #include "rexxhostbase.h"
  34.  
  35.     /* Forward declarations. */
  36.  
  37. extern struct MsgPort    *CreatePort();
  38. extern struct MsgPort    *FindPort();
  39. extern struct RexxMsg    *CreateRexxMsg();
  40. extern STRPTR         CreateArgstring();
  41.  
  42.     /* Global version identifier. */
  43.  
  44. LONG Version = REVISION;
  45.  
  46.     /* CreateRexxHost(HostName) :
  47.      *
  48.      *    Creates a MsgPort with a given name. Returns
  49.      *    NULL if port already exists.
  50.      */
  51.  
  52. struct MsgPort *
  53. CreateRexxHost(HostName)
  54. register STRPTR HostName;
  55. {
  56.         /* Already present? */
  57.  
  58.     if(FindPort(HostName))
  59.         return(NULL);
  60.  
  61.         /* Create it. */
  62.  
  63.     return(CreatePort(HostName,0));
  64. }
  65.  
  66.     /* DeleteRexxHost(MessagePort) :
  67.      *
  68.      *    Deletes a MsgPort as created by CreateRexxHost().
  69.      */
  70.  
  71. void
  72. DeleteRexxHost(MessagePort)
  73. struct MsgPort *MessagePort;
  74. {
  75.     if(MessagePort)
  76.         DeletePort(MessagePort);
  77. }
  78.  
  79.     /* SendRexxCommand(HostPort,CommandString,FileExtension,HostName) :
  80.      *
  81.      *    Sends a command to the rexx server, requires pointer
  82.      *    to the MsgPort of the calling Host, the command string;
  83.      *    file extension and host name are optional and may be
  84.      *    NULL.
  85.      */
  86.  
  87. LONG
  88. SendRexxCommand(HostPort,CommandString,FileExtension,HostName)
  89. register struct MsgPort *HostPort;
  90. register STRPTR CommandString,FileExtension,HostName;
  91. {
  92.     register struct MsgPort    *RexxPort = (struct MsgPort *)FindPort(RXSDIR);
  93.     register struct RexxMsg    *HostMessage;
  94.  
  95.         /* Valid pointers given? */
  96.  
  97.     if(!CommandString || !HostPort || !RexxPort)
  98.         return(FALSE);
  99.  
  100.         /* No special host name given? Take the MsgPort name. */
  101.  
  102.     if(!HostName)
  103.         HostName = (STRPTR)HostPort -> mp_Node . ln_Name;
  104.  
  105.         /* No file name extension? Take the default. */
  106.  
  107.     if(!FileExtension)
  108.         FileExtension = (STRPTR)"rexx";
  109.  
  110.         /* Create the message. */
  111.  
  112.     if(!(HostMessage = (struct RexxMsg *)CreateRexxMsg(HostPort,FileExtension,HostName)))
  113.         return(FALSE);
  114.  
  115.         /* Add the command. */
  116.  
  117.     if(!(HostMessage -> rm_Args[0] = (STRPTR)CreateArgstring(CommandString,strlen(CommandString))))
  118.     {
  119.         DeleteRexxMsg(HostMessage);
  120.         return(FALSE);
  121.     }
  122.  
  123.         /* This is a command, not a function. */
  124.  
  125.     HostMessage -> rm_Action = RXCOMM;
  126.  
  127.         /* Release it... */
  128.  
  129.     PutMsg(RexxPort,HostMessage);
  130.  
  131.     return(TRUE);
  132. }
  133.  
  134.     /* FreeRexxCommand(RexxMessage) :
  135.      *
  136.      *    Frees the contents of a RexxMsg.
  137.      */
  138.  
  139. void
  140. FreeRexxCommand(RexxMessage)
  141. register struct RexxMsg *RexxMessage;
  142. {
  143.         /* Valid pointer given? */
  144.  
  145.     if(!RexxMessage)
  146.         return;
  147.  
  148.         /* Remove argument. */
  149.  
  150.     if(RexxMessage -> rm_Args[0])
  151.         DeleteArgstring(RexxMessage -> rm_Args[0]);
  152.  
  153.         /* Free the message. */
  154.  
  155.     DeleteRexxMsg(RexxMessage);
  156. }
  157.  
  158.     /* ReplyRexxCommand(RexxMessage,Primary,Secondary,Result) :
  159.      *
  160.      *    Send a RexxMsg back to the rexx server, can include
  161.      *    result codes.
  162.      */
  163.  
  164. void
  165. ReplyRexxCommand(RexxMessage,Primary,Secondary,Result)
  166. register struct RexxMsg *RexxMessage;
  167. register LONG Primary,Secondary;
  168. register STRPTR Result;
  169. {
  170.         /* Valid pointer given? */
  171.  
  172.     if(!RexxMessage)
  173.         return;
  174.  
  175.         /* No primary result and results wanted? */ 
  176.  
  177.     if(Primary == 0 && (RexxMessage -> rm_Action & 1 << RXFB_RESULT))
  178.     {
  179.         Secondary = NULL;
  180.  
  181.             /* Form result string... */
  182.  
  183.         if(Result)
  184.             Secondary = (LONG)CreateArgstring(Result,strlen(Result));
  185.     }
  186.  
  187.         /* Set both results... */
  188.  
  189.     RexxMessage -> rm_Result1 = Primary;
  190.     RexxMessage -> rm_Result2 = Secondary;
  191.  
  192.         /* ...and reply the message. */
  193.  
  194.     ReplyMsg(RexxMessage);
  195. }
  196.  
  197.     /* GetRexxCommand(RexxMessage) :
  198.      *
  199.      *    Returns a pointer to the command string if
  200.      *    the RexxMsg is a command request.
  201.      */
  202.  
  203. STRPTR
  204. GetRexxCommand(RexxMessage)
  205. register struct RexxMsg *RexxMessage;
  206. {
  207.     if(RexxMessage -> rm_Node . mn_Node . ln_Type == NT_REPLYMSG || !RexxMessage)
  208.         return(NULL);
  209.  
  210.     return(RexxMessage -> rm_Args[0]);
  211. }
  212.  
  213.     /* GetRexxArg(RexxMessage) :
  214.      *
  215.      *    Returns a pointer to the first RexxMsg argument.
  216.      */
  217.  
  218. STRPTR
  219. GetRexxArg(RexxMessage)
  220. register struct RexxMsg *RexxMessage;
  221. {
  222.     if(!RexxMessage)
  223.         return(NULL);
  224.  
  225.     return(RexxMessage -> rm_Args[0]);
  226. }
  227.  
  228.     /* GetRexxResult1(RexxMessage) :
  229.      *
  230.      *    Returns the 1st RexxMsg result.
  231.      */
  232.  
  233. LONG
  234. GetRexxResult1(RexxMessage)
  235. register struct RexxMsg *RexxMessage;
  236. {
  237.     if(!RexxMessage)
  238.         return(NULL);
  239.  
  240.     return(RexxMessage -> rm_Result1);
  241. }
  242.  
  243.     /* GetRexxResult2(RexxMessage) :
  244.      *
  245.      *    Returns the 2nd RexxMsg result.
  246.      */
  247.  
  248. LONG
  249. GetRexxResult2(RexxMessage)
  250. register struct RexxMsg *RexxMessage;
  251. {
  252.     if(!RexxMessage)
  253.         return(NULL);
  254.  
  255.     return(RexxMessage -> rm_Result2);
  256. }
  257.  
  258.     /* GetToken(String,StartChar,AuxBuff,MaxLength) :
  259.      *
  260.      *    Fills a string with the next given string
  261.      *    argument.
  262.      */
  263.  
  264. UBYTE *
  265. GetToken(String,StartChar,AuxBuff,MaxLength)
  266. UBYTE *String,*AuxBuff;
  267. LONG *StartChar,MaxLength;
  268. {
  269.     LONG i,StrEnd = 0,MaxPos = strlen(String);
  270.  
  271.         /* Last counter position. */
  272.  
  273.     if(MaxPos >= MaxLength)
  274.         MaxPos = MaxLength - 1;
  275.  
  276.         /* Already finished with argument string? */
  277.  
  278.     if(*StartChar > strlen(String) - 1 || !strlen(String) || !String || !AuxBuff || !MaxLength)
  279.         return(NULL);
  280.  
  281.         /* Parse the argument string... */
  282.  
  283.     for(i = *StartChar ; i <= MaxPos ; i++)
  284.     {
  285.             /* Skip leading blanks... */
  286.  
  287.         if(!StrEnd && String[i] == ' ')
  288.         {
  289.             while(String[i] == ' ' && i < MaxPos)
  290.             {
  291.                 i++;
  292.                 (*StartChar)++;
  293.             }
  294.         }
  295.  
  296.             /* Found an argument. */
  297.  
  298.         if(String[i] == ' ' || String[i] == 0)
  299.         {
  300.                 /* Copy it to the auxiliary buffer. */
  301.  
  302.             strncpy(AuxBuff,String + *StartChar,StrEnd);
  303.             AuxBuff[StrEnd] = 0;
  304.  
  305.                 /* Change the position counter (since
  306.                  * we can't use static data initialisation
  307.                  * calling program has to supply a
  308.                  * counter variable).
  309.                  */
  310.  
  311.             (*StartChar) += StrEnd;
  312.  
  313.             return(AuxBuff);
  314.         }
  315.  
  316.             /* Increment character counter. */
  317.  
  318.         StrEnd++;
  319.     }
  320.  
  321.     return(NULL);
  322. }
  323.  
  324.     /* GetStringValue(String) :
  325.      *
  326.      *    Returns the numeric value taken from given string
  327.      *    (just like atoi(), taken from example source code
  328.      *    by K&R).
  329.      */
  330.  
  331. LONG
  332. GetStringValue(String)
  333. register UBYTE *String;
  334. {
  335.     register LONG i,Value,Sign = 1;
  336.  
  337.     if(!String || !String[0])
  338.         return(0);
  339.  
  340.     for(i = 0 ; String[i] == ' ' || String[i] == '\n' || String[i] == '\t' ; i++);
  341.  
  342.     if(String[i] == '+' || String[i] == '-')
  343.         Sign = (String[i++] == '+') ? 1 : -1;
  344.  
  345.     for(Value = 0 ; String[i] >= '0' && String[i] <= '9' ; i++)
  346.         Value = 10 * Value + String[i] - '0';
  347.  
  348.     return(Sign * Value);
  349. }
  350.  
  351.     /* BuildValueString(Value,String) :
  352.      *
  353.      *    Puts a numeric value in decimal form into a
  354.      *    given string (similar to itoa(), taken from
  355.      *    example source code by K&R).
  356.      */
  357.  
  358. UBYTE *
  359. BuildValueString(Value,String)
  360. LONG Value;
  361. UBYTE *String;
  362. {
  363.     LONG i = 0,j,c,Sign;
  364.  
  365.     if(!String)
  366.         return(NULL);
  367.  
  368.     if((Sign = Value) < 0)
  369.         Value = -Value;
  370.  
  371.     do
  372.         String[i++] = Value % 10 + '0';
  373.     while((Value /= 10) > 0);
  374.  
  375.     if(Sign < 0)
  376.         String[i++] = '-';
  377.  
  378.     String[i] = 0;
  379.  
  380.     for(i = 0,j = strlen(String) - 1 ; i < j ; i++,j--)
  381.     {
  382.         c        = String[i];
  383.         String[i]    = String[j];
  384.         String[j]    = c;
  385.     }
  386.  
  387.     return(String);
  388. }
  389.